home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / CodeTextView.C < prev    next >
C/C++ Source or Header  |  1992-08-24  |  10KB  |  482 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "CodeTextView.h"
  6.  
  7. #include "Class.h"
  8. #include "StyledText.h"
  9. #include "RunArray.h"
  10. #include "Env.h"
  11. #include "Math.h"
  12.  
  13. static char *match     = "lass",
  14.         *obrackets = "({[\"",
  15.         *cbrackets = ")}]\"";
  16.  
  17. //---- CodeTextView ------------------------------------------------------------
  18.  
  19. NewMetaImpl(CodeTextView,TextView, (TB(autoIndent), T(cursorPos)));
  20.  
  21. CodeTextView::CodeTextView(
  22.     EvtHandler *eh, Rectangle r, Text *t, 
  23.     bool w, TextViewFlags f, Point b, 
  24.     TViewAlign ta, int id
  25. ) : TextView(eh, r, t, w, f, b, ta, id) 
  26. {
  27.     SetStopChars("\n\r");
  28.     autoIndent= TRUE;
  29.     SetupStyles(t->GetFont());
  30.     ExitCursorMode();
  31. }   
  32.  
  33. Command *CodeTextView::DoKeyCommand(int ch, Token token)
  34. {
  35.     Command *cmd;
  36.  
  37.     ExitCursorMode();
  38.     if ((ch == '\r' || ch == '\n') && autoIndent) { // auto indent
  39.     int from, to, i;
  40.     Text *t= GetText();
  41.     GetSelection(&from, &to);
  42.     scratchText->Empty();
  43.     scratchText->Append('\n'); 
  44.     for (i= StartLine(CharToLine(from)); i < t->End(); i++) {
  45.         ch= (*t)[i];
  46.         if (ch == ' ' || ch == '\t')
  47.         scratchText->Append(ch);
  48.         else
  49.         break;
  50.     }
  51.     cmd= InsertText(scratchText);
  52.     scratchText->Empty();
  53.     RevealSelection();
  54.     return cmd;
  55.     }
  56.     return TextView::DoKeyCommand(ch, token);
  57. }
  58.  
  59. void CodeTextView::SetFont(Font *fp)
  60. {
  61.     SetupStyles(fp);
  62.     TextView::SetFont(fp);
  63. }
  64.  
  65. void CodeTextView::SetupStyles(Font *fp)
  66. {
  67.     int declsize= fp->Size()
  68.           + Env::GetValue("CodeText.DeclarationSizeIncrement", 2);
  69.           
  70.     commentStyle= new_CharStyle(
  71.     new_Font(fp->Fid(), fp->Size(), eFaceItalic)
  72.     );
  73.     functionStyle= new_CharStyle(
  74.     new_Font(fp->Fid(), declsize, eFaceBold)
  75.     );
  76.     classDeclStyle= new_CharStyle(
  77.     new_Font(fp->Fid(), declsize, eFaceBold)
  78.     );
  79.     plainStyle= new_CharStyle(
  80.     new_Font(fp->Fid(), fp->Size(), eFacePlain)
  81.     );
  82. }
  83.  
  84. void CodeTextView::SetAutoIndent(bool b)
  85. {
  86.     autoIndent= b;
  87. }
  88.     
  89. bool CodeTextView::GetAutoIndent()
  90. {
  91.     return autoIndent;
  92. }
  93.  
  94. void CodeTextView::ExitCursorMode()
  95. {
  96.     cursorPos= gPoint_1;
  97. }
  98.  
  99. Command *CodeTextView::DoLeftButtonDownCommand(Point p, Token t, int cl)
  100. {
  101.     Point sp= p;
  102.     ExitCursorMode();
  103.     if (!Enabled())
  104.     return gNoChanges;
  105.     if (cl >= 2) {
  106.     int line, cpos;
  107.     char *br;
  108.     Point pp;
  109.     Text *text= GetText();
  110.  
  111.     p-= GetInnerOrigin();
  112.     PointToPoint(p, &pp, &line, &cpos);
  113.     
  114.     if (cpos > 0 && (br= strchr(obrackets,(*text)[cpos-1]))) {
  115.         MatchBracketForward(cpos, *br, cbrackets[br-obrackets]);
  116.         return gNoChanges;
  117.     }
  118.     if (cpos < text->End() && (br= strchr(cbrackets,(*text)[cpos]))) {
  119.         MatchBracketBackward(cpos-1, obrackets[br-cbrackets], *br);
  120.         return gNoChanges;
  121.     }
  122.     }
  123.     return TextView::DoLeftButtonDownCommand(sp, t, cl);
  124. }
  125.  
  126. Command *CodeTextView::DoMenuCommand(int m)
  127. {
  128.     ExitCursorMode();
  129.     return TextView::DoMenuCommand(m);
  130. }
  131.     
  132. Command *CodeTextView::DoOtherEventCommand(Point p, Token t)
  133. {
  134.     ExitCursorMode();
  135.     return TextView::DoOtherEventCommand(p, t);
  136. }
  137.  
  138. void CodeTextView::MatchBracketForward(int from, int obracket, int cbracket)
  139. {
  140.     Text *text= GetText();
  141.     int ch, stack= 0;
  142.  
  143.     for (int i= from; i < text->End(); i++) {
  144.     ch= (*text)[i];
  145.     if (ch == cbracket) {
  146.         if (stack-- == 0) 
  147.         break;
  148.     } else if (ch == obracket)
  149.         stack++;
  150.     }    
  151.     SetSelection(from, i, TRUE);
  152. }
  153.  
  154. void CodeTextView::MatchBracketBackward(int from, int obracket, int cbracket)
  155. {
  156.     Text *text= GetText();
  157.     int ch, stack= 0;
  158.  
  159.     for (int i= from; i >= 0; i--) {
  160.     ch= (*text)[i];
  161.     if (ch == obracket) { 
  162.         if (stack-- == 0) 
  163.         break;
  164.     } else if (ch == cbracket)
  165.         stack++;
  166.     }
  167.     SetSelection(i+1, from+1, TRUE);
  168. }
  169.  
  170. Command *CodeTextView::DoCursorKeyCommand(EvtCursorDir cd, Token t)
  171. {
  172.     if (cd == eCrsLeft || cd == eCrsRight)
  173.     ExitCursorMode();
  174.     return TextView::DoCursorKeyCommand(cd, t);
  175. }
  176.  
  177. int CodeTextView::CursorPos(int at, int line, EvtCursorDir d, Point p)
  178. {    
  179.     int charNo;
  180.     Point basePoint;
  181.     
  182.     if (cursorPos == gPoint_1) 
  183.     CharToPoint(at, &line, &cursorPos);
  184.  
  185.     if (d == eCrsDown)
  186.     line= Math::Min(nLines-1, line+1);
  187.     else
  188.     line= Math::Max(0, line-1);        
  189.     basePoint= LineToPoint(line, TRUE) + Point(cursorPos.x, 0);
  190.     PointToPoint(basePoint, &p, &line, &charNo);
  191.     return charNo;
  192. }
  193.  
  194. PrettyPrinter *CodeTextView::MakePrettyPrinter(
  195.     Text *t, CharStyle *cs, CharStyle *fs, CharStyle *cds, CharStyle *ps
  196. ) 
  197. {
  198.     return new PrettyPrinter(t, cs, fs, cds, ps);
  199. }
  200.  
  201. void CodeTextView::FormatCode()
  202. {
  203.     if (!text->IsKindOf(StyledText)) 
  204.     return;
  205.     PrettyPrinter *pp= MakePrettyPrinter(
  206.     text, commentStyle, functionStyle, classDeclStyle, plainStyle
  207.     );
  208.     pp->Doit();
  209.     SafeDelete(pp);
  210. }
  211.  
  212. void CodeTextView::SetDefaultStyle()
  213. {
  214.     if (!text->IsKindOf(StyledText)) 
  215.     return;
  216.     StyledText *stext= (StyledText*)text;
  217.     RunArray *st= new RunArray();
  218.     st->Insert(plainStyle, 0, 0, stext->Size());
  219.     RunArray *tmpp= stext->SetCharStyles(st);
  220.     delete tmpp;
  221. }
  222.  
  223. //---- CodeAnalyzer ----------------------------------------------------------
  224.  
  225. CodeAnalyzer::CodeAnalyzer(Text *t)
  226. {
  227.     text= t;
  228. }
  229.  
  230. void CodeAnalyzer::Doit()
  231. {
  232.     inDefine= escape= inClass= FALSE;
  233.     lastComment= prevCh= braceStack= inString= line= 0;
  234.     c= '\n'; 
  235.     int canBeClass= canBeFunction= -1;
  236.  
  237.     AutoTextIter next(text, 0, text->Size());
  238.     Start();
  239.     
  240.     while ((c= next()) != cEOT) {
  241.     if (escape)
  242.         escape=FALSE;
  243.     else
  244.         switch (c) {
  245.         case '#':
  246.         if (prevCh == '\n')
  247.             inDefine= TRUE;
  248.         break;
  249.         case '\\':
  250.         escape= TRUE;
  251.         break;
  252.         case '\n':
  253.         inDefine= FALSE;
  254.         line++;
  255.         break;
  256.         case '*':
  257.         if (prevCh == '/' && inString == 0) {
  258.             if (canBeFunction == -1 && canBeClass == -1)
  259.             lastComment= next->GetPos(); 
  260.             FoundComment(&next);
  261.             prevCh= 0;
  262.             continue;
  263.         }
  264.         break;
  265.         case '/':
  266.         if (prevCh == '/' && inString == 0) {
  267.             if (canBeFunction == -1 && canBeClass == -1)
  268.             lastComment= next->GetPos(); 
  269.             FoundEndOfLineComment(&next);
  270.             prevCh= 0;
  271.             continue;
  272.         }
  273.         break;
  274.         case ';':
  275.         canBeFunction= canBeClass= -1;
  276.         break;
  277.         case '{':
  278.         if (canBeFunction != -1) {
  279.             FoundFunctionOrMethod(canBeFunction, lastComment);
  280.             canBeFunction= -1;
  281.         }
  282.         if (canBeClass != -1) {
  283.             FoundClassDecl(canBeClass);
  284.             canBeClass= -1;
  285.         }
  286.         if (inString == 0)
  287.             braceStack++;
  288.         break;
  289.         case '}':
  290.         if (inString == 0)
  291.             braceStack--;
  292.         break;
  293.         case '(':
  294.         if (!inDefine && inString == 0) {
  295.             if (braceStack == 0 && canBeFunction == -1)
  296.             canBeFunction= next->GetPos()-1;
  297.             braceStack++;
  298.         }
  299.         break;
  300.         case ')':
  301.         if (!inDefine && inString == 0)
  302.             braceStack--;
  303.         break;
  304.         case '\'':
  305.         case '\"':
  306.         if (inString == 0) {
  307.             if (c == '\"')
  308.             inString= '\"';
  309.             else
  310.             inString= '\'';
  311.         } else {
  312.             if ((inString == '\"' && c == '\"') || (inString == '\'' 
  313.                              && c == '\''))
  314.             inString= 0;
  315.         }
  316.         break;
  317.         default:
  318.         if (c == 'c' && !inDefine && inString == 0 
  319.             && !inClass && canBeClass == -1) {
  320.             if (braceStack == 0)
  321.             if (inClass= IsClassDecl(next->GetPos()))
  322.                 next->SetPos(next->GetPos()+4);
  323.         } else if (inClass && Isinword(c)) {
  324.             inClass= FALSE;
  325.             canBeClass= next->GetPos();
  326.         }
  327.         break;
  328.     }
  329.     prevCh= c;
  330.     }
  331.     End();
  332. }
  333.  
  334. void CodeAnalyzer::FoundComment(AutoTextIter *next)
  335. {
  336.     int c, prevCh= 0, l= line, start= (*next)->GetPos()-2;
  337.    
  338.     while ((c= (*next)()) != cEOT) {
  339.     if (c == '\n')
  340.         line++;
  341.     if (c == '/' && prevCh == '*') {
  342.         Comment(l, start, (*next)->GetPos());
  343.         break;
  344.     }
  345.     prevCh= c;
  346.     }
  347. }
  348.  
  349. void CodeAnalyzer::FoundEndOfLineComment(AutoTextIter *next)
  350. {
  351.     int c, start= (*next)->GetPos()-2;
  352.  
  353.     while ((c= (*next)()) != cEOT) 
  354.     if (c == '\n') {
  355.         Comment(line, start, (*next)->GetPos()-1);
  356.         line++;
  357.         break;
  358.     }
  359. }
  360.  
  361. void CodeAnalyzer::FoundFunctionOrMethod(int at, int lastComment)
  362. {
  363.     byte c;
  364.     int pos= at, len= 0;
  365.     while (--pos >= lastComment) {
  366.     c= (*text)[pos];
  367.     if (!Isspace(c) && !strchr("[]*+-=%&><|:^%()~/",c)) // overloaded operators
  368.         break;
  369.     }
  370.     while (pos >= lastComment) {
  371.     c= (*text)[pos];
  372.     if (!(Isinword(c) || c == ':' || c == '~' ))
  373.         break;
  374.     if (pos-1 < 0)
  375.         break;
  376.     pos--;
  377.     len++;
  378.     }
  379.     
  380.     if (len) {
  381.     char buf[500];
  382.     pos++;
  383.     text->CopyInStr((byte*)buf, sizeof buf, pos, pos+len);
  384.     char *p= strchr(buf, ':');
  385.     if (!p)
  386.         Function(line, pos, pos+len, buf, 0);
  387.     else {
  388.         *p= '\0';
  389.         char *pp= p+2;
  390.         Function(line, pos, pos+len, pp, buf);
  391.     }
  392.     }
  393. }
  394.  
  395. bool CodeAnalyzer::IsClassDecl(int at)
  396. {
  397.     char *p= match;
  398.     int c;
  399.     AutoTextIter next(text, at, text->Size());
  400.  
  401.     while ((c= next()) != cEOT && *p)
  402.     if (c != *p++) 
  403.         return FALSE;
  404.     return TRUE;
  405. }
  406.  
  407. void CodeAnalyzer::FoundClassDecl(int at)
  408. {
  409.     int end, c, start= at-1;
  410.     AutoTextIter next(text, start, text->Size());
  411.  
  412.     while ((c= next()) != cEOT) 
  413.     if (!Isinword(c)) 
  414.         break;
  415.     end= next->GetPos()-1;
  416.     if (start != end) {
  417.     static byte name[1000];
  418.     text->CopyInStr(name, sizeof name, start, end);
  419.     ClassDecl(line, start, end, (char*)name);
  420.     }
  421. }
  422.  
  423. void CodeAnalyzer::Start()
  424. {
  425. }
  426.  
  427. void CodeAnalyzer::End()
  428. {
  429. }
  430.  
  431. void CodeAnalyzer::Comment(int, int, int)
  432. {
  433. }
  434.  
  435. void CodeAnalyzer::ClassDecl(int, int, int, char *)
  436. {
  437. }
  438.     
  439. void CodeAnalyzer::Function(int, int, int, char *, char *)
  440. {
  441. }
  442.  
  443. //---- PrettyPrinter ---------------------------------------------------------
  444.  
  445. PrettyPrinter::PrettyPrinter(
  446.     Text *t, CharStyle *cs, CharStyle *fs, CharStyle *cds, CharStyle *ps
  447. ) : CodeAnalyzer(t)
  448. {
  449.     stext= Guard(t, StyledText);
  450.     plainStyle= ps;
  451.     commentStyle= cs;
  452.     classDeclStyle= cds;
  453.     functionStyle= fs;
  454. }
  455.  
  456. void PrettyPrinter::Start()
  457. {
  458.     st= new RunArray();
  459.     st->Insert(plainStyle, 0, 0, stext->Size());
  460. }
  461.  
  462. void PrettyPrinter::End()
  463. {
  464.     RunArray *tmpp= stext->SetCharStyles(st);
  465.     delete tmpp;
  466. }
  467.  
  468. void PrettyPrinter::Comment(int, int start, int end)
  469. {
  470.     st->Insert(commentStyle, start, end, end-start);
  471. }
  472.  
  473. void PrettyPrinter::ClassDecl(int, int start, int end, char *)
  474. {
  475.     st->Insert(classDeclStyle, start, end, end-start);
  476. }
  477.     
  478. void PrettyPrinter::Function(int, int start, int end, char *, char *)
  479. {
  480.     st->Insert(functionStyle, start, end, end-start);
  481. }
  482.